package com.neuedu.his.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.neuedu.his.po.Patient;
import com.neuedu.his.service.PatientService;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/patients")
public class PatientController {

    private static final Logger log = LoggerFactory.getLogger(PatientController.class);

    @Autowired
    private PatientService patientService;

    /**
     * 自定义DTO类，用于转换字段名为驼峰式（与前端匹配）
     */
    static class PatientDTO {
        private Integer id;
        private String caseNumber; // 病历号（对应实体类casenumber）
        private String realName;   // 姓名（对应实体类realname）
        private Integer age;       // 年龄
        private Integer registerId;// 挂号员ID（对应实体类registerid）
        private Integer visitState;// 就诊状态（对应实体类visitstate）
        private Integer visitstate;// 兼容原字段（避免前端状态判断错误）

        // 构造方法：从Patient实体类转换为DTO
        public PatientDTO(Patient patient) {
            this.id = patient.getId();
            this.caseNumber = patient.getCasenumber(); // 实体类casenumber -> DTO caseNumber
            this.realName = patient.getRealname();     // 实体类realname -> DTO realName
            this.age = patient.getAge();
            this.registerId = patient.getRegisterid(); // 实体类registerid -> DTO registerId
            this.visitState = patient.getVisitstate(); // 实体类visitstate -> DTO visitState
            this.visitstate = patient.getVisitstate(); // 保留原字段，避免前端状态判断异常
        }

        // getter和setter（自动生成即可）
        public Integer getId() { return id; }
        public void setId(Integer id) { this.id = id; }
        public String getCaseNumber() { return caseNumber; }
        public void setCaseNumber(String caseNumber) { this.caseNumber = caseNumber; }
        public String getRealName() { return realName; }
        public void setRealName(String realName) { this.realName = realName; }
        public Integer getAge() { return age; }
        public void setAge(Integer age) { this.age = age; }
        public Integer getRegisterId() { return registerId; }
        public void setRegisterId(Integer registerId) { this.registerId = registerId; }
        public Integer getVisitState() { return visitState; }
        public void setVisitState(Integer visitState) { this.visitState = visitState; }
        public Integer getVisitstate() { return visitstate; }
        public void setVisitstate(Integer visitstate) { this.visitstate = visitstate; }
    }

    /**
     * 获取医生的所有患者（未诊和已诊），返回DTO列表（字段名驼峰式）
     */
    @GetMapping("/doctor")
    public ResponseEntity<Map<String, List<PatientDTO>>> getDoctorPatients(
            @RequestParam(required = true) Integer doctorId) {
        if (doctorId == null || doctorId <= 0) {
            log.warn("获取医生患者失败：doctorId无效，doctorId={}", doctorId);
            return ResponseEntity.badRequest().build();
        }

        try {
            Map<String, List<PatientDTO>> result = new HashMap<>();

            // 查询未诊患者并转换为DTO
            QueryWrapper<Patient> unvisitedWrapper = new QueryWrapper<>();
            unvisitedWrapper.eq("userid", doctorId) // 注意：实体类中医生ID是userid（小写）
                    .eq("visitstate", 0); // 实体类中就诊状态是visitstate（小写）
            List<Patient> unvisitedPatients = patientService.list(unvisitedWrapper);
            List<PatientDTO> unvisitedDTOs = unvisitedPatients.stream()
                    .map(PatientDTO::new)
                    .toList();

            // 查询已诊患者并转换为DTO
            QueryWrapper<Patient> visitedWrapper = new QueryWrapper<>();
            visitedWrapper.eq("userid", doctorId)
                    .eq("visitstate", 2);
            List<Patient> visitedPatients = patientService.list(visitedWrapper);
            List<PatientDTO> visitedDTOs = visitedPatients.stream()
                    .map(PatientDTO::new)
                    .toList();

            result.put("unvisited", unvisitedDTOs);
            result.put("visited", visitedDTOs);

            log.info("获取医生患者成功，doctorId={}，未诊数量={}，已诊数量={}",
                    doctorId, unvisitedDTOs.size(), visitedDTOs.size());
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            log.error("获取医生患者异常，doctorId={}", doctorId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 获取医生的未诊患者（返回DTO列表）
     */
    @GetMapping("/unvisited")
    public ResponseEntity<List<PatientDTO>> getUnvisitedPatients(
            @RequestParam(required = true) Integer doctorId) {
        if (doctorId == null || doctorId <= 0) {
            log.warn("获取未诊患者失败：doctorId无效，doctorId={}", doctorId);
            return ResponseEntity.badRequest().build();
        }

        try {
            QueryWrapper<Patient> wrapper = new QueryWrapper<>();
            wrapper.eq("userid", doctorId) // 实体类中医生ID是userid（小写）
                    .eq("visitstate", 0);
            List<Patient> patients = patientService.list(wrapper);
            // 转换为DTO
            List<PatientDTO> dtos = patients.stream().map(PatientDTO::new).toList();
            log.info("获取未诊患者成功，doctorId={}，数量={}", doctorId, dtos.size());
            return ResponseEntity.ok(dtos);
        } catch (Exception e) {
            log.error("获取未诊患者异常，doctorId={}", doctorId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 获取医生的已诊患者（返回DTO列表）
     */
    @GetMapping("/visited")
    public ResponseEntity<List<PatientDTO>> getVisitedPatients(
            @RequestParam(required = true) Integer doctorId) {
        if (doctorId == null || doctorId <= 0) {
            log.warn("获取已诊患者失败：doctorId无效，doctorId={}", doctorId);
            return ResponseEntity.badRequest().build();
        }

        try {
            QueryWrapper<Patient> wrapper = new QueryWrapper<>();
            wrapper.eq("userid", doctorId)
                    .eq("visitstate", 2);
            List<Patient> patients = patientService.list(wrapper);
            List<PatientDTO> dtos = patients.stream().map(PatientDTO::new).toList();
            log.info("获取已诊患者成功，doctorId={}，数量={}", doctorId, dtos.size());
            return ResponseEntity.ok(dtos);
        } catch (Exception e) {
            log.error("获取已诊患者异常，doctorId={}", doctorId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 搜索患者（按姓名）
     */
    @GetMapping("/search")
    public ResponseEntity<Map<String, List<PatientDTO>>> searchPatients(
            @RequestParam String keyword,
            @RequestParam(required = false) Integer doctorId,
            @RequestParam(required = false) Integer deptId) {
        try {
            QueryWrapper<Patient> wrapper = new QueryWrapper<>();
            wrapper.like("realname", keyword); // 按实体类realname搜索

            Map<String, List<PatientDTO>> result = new HashMap<>();

            // 本人患者（需医生ID）
            if (doctorId != null && doctorId > 0) {
                // 未诊患者
                List<Patient> unvisited = patientService.list(wrapper.clone()
                        .eq("userid", doctorId)
                        .eq("visitstate", 0));
                result.put("unvisited", unvisited.stream().map(PatientDTO::new).toList());

                // 已诊患者
                List<Patient> visited = patientService.list(wrapper.clone()
                        .eq("userid", doctorId)
                        .eq("visitstate", 2));
                result.put("visited", visited.stream().map(PatientDTO::new).toList());
            }

            // 科室患者（需科室ID）
            if (deptId != null && deptId > 0) {
                List<Patient> deptUnvisited = patientService.list(wrapper.clone()
                        .eq("deptid", deptId)
                        .eq("visitstate", 0));
                result.put("deptUnvisited", deptUnvisited.stream().map(PatientDTO::new).toList());

                List<Patient> deptVisited = patientService.list(wrapper.clone()
                        .eq("deptid", deptId)
                        .eq("visitstate", 2));
                result.put("deptVisited", deptVisited.stream().map(PatientDTO::new).toList());
            }

            log.info("搜索患者成功，关键词={}，总数量={}", keyword,
                    result.values().stream().mapToInt(List::size).sum());
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            log.error("搜索患者异常，关键词={}", keyword, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 更新患者就诊状态（诊毕）
     */
    @PutMapping("/{id}/status")
    public ResponseEntity<Void> updatePatientStatus(
            @PathVariable Integer id,
            @RequestBody Map<String, String> statusMap) {
        try {
            String status = statusMap.get("status");
            if (id == null || id <= 0 || status == null || status.trim().isEmpty()) {
                log.warn("更新患者状态失败：参数无效，id={}，status={}", id, status);
                return ResponseEntity.badRequest().build();
            }

            Patient patient = patientService.getById(id);
            if (patient == null) {
                log.warn("更新患者状态失败：患者不存在，id={}", id);
                return ResponseEntity.notFound().build();
            }

            // 更新患者状态（实体类中是visitstate字段）
            if ("visited".equals(status)) {
                patient.setVisitstate(2); // 2表示已诊
            } else if ("unvisited".equals(status)) {
                patient.setVisitstate(0); // 0表示未诊
            } else {
                log.warn("更新患者状态失败：不支持的状态值，id={}，status={}", id, status);
                return ResponseEntity.badRequest().build();
            }

            boolean success = patientService.updateById(patient);
            if (success) {
                log.info("更新患者状态成功，id={}，status={}", id, status);
                return ResponseEntity.ok().build();
            } else {
                log.warn("更新患者状态失败，id={}，status={}", id, status);
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
            }
        } catch (Exception e) {
            log.error("更新患者状态异常，id={}", id, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    // 科室患者相关接口（省略，按上述DTO转换逻辑修改即可）
}